package service

import (
	"errors"
	"sysu-giep/internal/database"
	"sysu-giep/internal/database/models"
	"sysu-giep/pkg/auth"
	"sysu-giep/pkg/logger"

	"gorm.io/gorm"
)

// UserService 用户服务
type UserService struct{}

// NewUserService 创建用户服务实例
func NewUserService() *UserService {
	return &UserService{}
}

// CreateUserWithExtraData 创建用户并处理额外字段
func (s *UserService) CreateUserWithExtraData(req *models.User, extraData map[string]interface{}) error {
	// 检查用户名是否已存在
	var existingUser models.User
	if err := database.DB.Where("username = ?", req.Username).First(&existingUser).Error; err == nil {
		return errors.New("用户名已存在")
	}

	// 检查邮箱是否已存在
	if err := database.DB.Where("email = ?", req.Email).First(&existingUser).Error; err == nil {
		return errors.New("邮箱已存在")
	}

	// 加密密码
	hashedPassword, err := auth.HashPassword(req.Password)
	if err != nil {
		logger.Error(errors.New("密码加密失败"))
		return errors.New("密码加密失败")
	}
	req.Password = hashedPassword

	// 开始事务
	tx := database.DB.Begin()
	if tx.Error != nil {
		return errors.New("开始事务失败")
	}

	// 创建用户
	if err := tx.Create(req).Error; err != nil {
		tx.Rollback()
		logger.Error(errors.New("创建用户失败"))
		return errors.New("创建用户失败")
	}

	// 根据角色创建对应的详细信息
	switch req.Role {
	case models.RoleStudent:
		student := &models.Student{
			UserID:        req.ID,
			StudentID:     "",   // 用户可以后续更新
			Major:         "",   // 用户可以后续更新
			Grade:         "",   // 用户可以后续更新
			Degree:        "本科", // 默认值
			ResearchField: "",   // 用户可以后续更新
			Skills:        "",   // 用户可以后续更新
			Experience:    "",   // 用户可以后续更新
			Projects:      "",   // 用户可以后续更新
			Introduction:  "",   // 用户可以后续更新
		}
		
		// 处理额外字段
		if extraData != nil {
			if dept, ok := extraData["department"].(string); ok && dept != "" {
				student.Major = dept // 将department映射到major字段
			}
			if researchDir, ok := extraData["research_direction"].([]string); ok && len(researchDir) > 0 {
				// 将研究方向数组转换为字符串，用逗号分隔
				researchFieldStr := ""
				for i, field := range researchDir {
					if i > 0 {
						researchFieldStr += ", "
					}
					researchFieldStr += field
				}
				student.ResearchField = researchFieldStr
			}
		}
		
		if err := tx.Create(student).Error; err != nil {
			tx.Rollback()
			logger.Error(errors.New("创建学生信息失败"))
			return errors.New("创建学生信息失败")
		}

	case models.RoleTutor:
		tutor := &models.Tutor{
			UserID:        req.ID,
			Title:         "", // 用户可以后续更新
			Department:    "", // 用户可以后续更新
			ResearchField: "", // 用户可以后续更新
			Education:     "", // 用户可以后续更新
			Experience:    "", // 用户可以后续更新
			Introduction:  "", // 用户可以后续更新
		}
		
		// 处理额外字段
		if extraData != nil {
			if dept, ok := extraData["department"].(string); ok && dept != "" {
				tutor.Department = dept
			}
			if researchDir, ok := extraData["research_direction"].([]string); ok && len(researchDir) > 0 {
				// 将研究方向数组转换为字符串，用逗号分隔
				researchFieldStr := ""
				for i, field := range researchDir {
					if i > 0 {
						researchFieldStr += ", "
					}
					researchFieldStr += field
				}
				tutor.ResearchField = researchFieldStr
			}
		}
		
		if err := tx.Create(tutor).Error; err != nil {
			tx.Rollback()
			logger.Error(errors.New("创建导师信息失败"))
			return errors.New("创建导师信息失败")
		}

	case models.RoleEnterprise:
		enterprise := &models.Enterprise{
			UserID:      req.ID,
			CompanyName: "", // 用户可以后续更新
			Industry:    "", // 用户可以后续更新
			CompanySize: "", // 用户可以后续更新
			Address:     "", // 用户可以后续更新
			Description: "", // 用户可以后续更新
		}
		
		// 处理额外字段
		if extraData != nil {
			if org, ok := extraData["organization"].(string); ok && org != "" {
				enterprise.CompanyName = org
			}
		}
		
		if err := tx.Create(enterprise).Error; err != nil {
			tx.Rollback()
			logger.Error(errors.New("创建企业信息失败"))
			return errors.New("创建企业信息失败")
		}
	}

	// 提交事务
	if err := tx.Commit().Error; err != nil {
		tx.Rollback()
		return errors.New("提交事务失败")
	}

	return nil
}

// CreateUser 创建用户（保持向后兼容）
func (s *UserService) CreateUser(req *models.User) error {
	// 检查用户名是否已存在
	var existingUser models.User
	if err := database.DB.Where("username = ?", req.Username).First(&existingUser).Error; err == nil {
		return errors.New("用户名已存在")
	}

	// 检查邮箱是否已存在
	if err := database.DB.Where("email = ?", req.Email).First(&existingUser).Error; err == nil {
		return errors.New("邮箱已存在")
	}

	// 加密密码
	hashedPassword, err := auth.HashPassword(req.Password)
	if err != nil {
		logger.Error(errors.New("密码加密失败"))
		return errors.New("密码加密失败")
	}
	req.Password = hashedPassword

	// 开始事务
	tx := database.DB.Begin()
	if tx.Error != nil {
		return errors.New("开始事务失败")
	}

	// 创建用户
	if err := tx.Create(req).Error; err != nil {
		tx.Rollback()
		logger.Error(errors.New("创建用户失败"))
		return errors.New("创建用户失败")
	}

	// 根据角色创建对应的详细信息
	switch req.Role {
	case models.RoleStudent:
		student := &models.Student{
			UserID:        req.ID,
			StudentID:     "",   // 用户可以后续更新
			Major:         "",   // 用户可以后续更新
			Grade:         "",   // 用户可以后续更新
			Degree:        "本科", // 默认值
			ResearchField: "",   // 用户可以后续更新
			Skills:        "",   // 用户可以后续更新
			Experience:    "",   // 用户可以后续更新
			Projects:      "",   // 用户可以后续更新
			Introduction:  "",   // 用户可以后续更新
		}
		if err := tx.Create(student).Error; err != nil {
			tx.Rollback()
			logger.Error(errors.New("创建学生信息失败"))
			return errors.New("创建学生信息失败")
		}

	case models.RoleTutor:
		tutor := &models.Tutor{
			UserID:        req.ID,
			Title:         "", // 用户可以后续更新
			Department:    "", // 用户可以后续更新
			ResearchField: "", // 用户可以后续更新
			Education:     "", // 用户可以后续更新
			Experience:    "", // 用户可以后续更新
			Introduction:  "", // 用户可以后续更新
		}
		if err := tx.Create(tutor).Error; err != nil {
			tx.Rollback()
			logger.Error(errors.New("创建导师信息失败"))
			return errors.New("创建导师信息失败")
		}

	case models.RoleEnterprise:
		enterprise := &models.Enterprise{
			UserID:      req.ID,
			CompanyName: "", // 用户可以后续更新
			Industry:    "", // 用户可以后续更新
			CompanySize: "", // 用户可以后续更新
			Address:     "", // 用户可以后续更新
			Description: "", // 用户可以后续更新
		}
		if err := tx.Create(enterprise).Error; err != nil {
			tx.Rollback()
			logger.Error(errors.New("创建企业信息失败"))
			return errors.New("创建企业信息失败")
		}
	}

	// 提交事务
	if err := tx.Commit().Error; err != nil {
		tx.Rollback()
		return errors.New("提交事务失败")
	}

	return nil
}

// GetUserByUsername 根据用户名获取用户
func (s *UserService) GetUserByUsername(username string) (*models.User, error) {
	var user models.User
	if err := database.DB.Where("username = ?", username).First(&user).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("用户不存在")
		}
		return nil, err
	}
	return &user, nil
}

// GetUserByEmail 根据邮箱获取用户
func (s *UserService) GetUserByEmail(email string) (*models.User, error) {
	var user models.User
	if err := database.DB.Where("email = ?", email).First(&user).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("用户不存在")
		}
		return nil, err
	}
	return &user, nil
}

// GetUserByID 根据ID获取用户
func (s *UserService) GetUserByID(id uint) (*models.User, error) {
	var user models.User
	if err := database.DB.Preload("Enterprise").Preload("Tutor").Preload("Student").First(&user, id).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("用户不存在")
		}
		return nil, err
	}
	return &user, nil
}

// UpdateUser 更新用户信息
func (s *UserService) UpdateUser(id uint, updates map[string]interface{}) error {
	if err := database.DB.Model(&models.User{}).Where("id = ?", id).Updates(updates).Error; err != nil {
		logger.Error(errors.New("更新用户失败"))
		return errors.New("更新用户失败")
	}
	return nil
}

// UpdateUserStatus 更新用户状态
func (s *UserService) UpdateUserStatus(id uint, status models.UserStatus) error {
	if err := database.DB.Model(&models.User{}).Where("id = ?", id).Update("status", status).Error; err != nil {
		logger.Error(errors.New("更新用户状态失败"))
		return errors.New("更新用户状态失败")
	}
	return nil
}

// GetUsers 获取用户列表
func (s *UserService) GetUsers(page, size int, role, status string) ([]models.User, int64, error) {
	var users []models.User
	var total int64

	query := database.DB.Model(&models.User{})

	// 添加筛选条件
	if role != "" {
		query = query.Where("role = ?", role)
	}
	if status != "" {
		query = query.Where("status = ?", status)
	}

	// 获取总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 分页查询
	offset := (page - 1) * size
	if err := query.Offset(offset).Limit(size).Find(&users).Error; err != nil {
		return nil, 0, err
	}

	return users, total, nil
}

// ChangePassword 修改密码
func (s *UserService) ChangePassword(id uint, oldPassword, newPassword string) error {
	// 获取用户
	user, err := s.GetUserByID(id)
	if err != nil {
		return err
	}

	// 验证旧密码
	if !auth.CheckPassword(oldPassword, user.Password) {
		return errors.New("旧密码错误")
	}

	// 加密新密码
	hashedPassword, err := auth.HashPassword(newPassword)
	if err != nil {
		return errors.New("密码加密失败")
	}

	// 更新密码
	if err := database.DB.Model(&models.User{}).Where("id = ?", id).Update("password", hashedPassword).Error; err != nil {
		return errors.New("密码更新失败")
	}

	return nil
}
